<!DOCTYPE html>
<html lang="zh">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>数组的方法</title>
    <script>
        /* 
        1.sort()    //破坏性方法
            1.用来对数组进行排序，会改变原数组。
            2.默认会将数组进行升序排列
            3.sort默认会根据Unicode编码顺序排序，所以直接通过sort对数字进行排序，可能会造成错误，所以使用回调函数可以解决这个问题。
            参数：
                可以用一个回调函数作为参数，通过回调函数来指定排序的规则，这种方法解决了Unicode编码带来的问题。

                arr.sort((a,b)=>a-b)      升序排列
                arr.sort((a,b)=>b-a)      降序排列

        2.forEach((element,indedx，array)=>{})          // 非破坏性方法
            用来遍历数组
            它需要一个回调函数做为参数，这个回调函数会被调用多次。
                数组中有几个元素，回调函数就调用多次。每次调用都会将数组中的数据做为参数传递
            
            回调函数需要三个参数
                element 数组中的元素
                index   数组中的索引
                array   当前被遍历的数组

        3.filter((element,indedx，array)=>{return true})      // 非破坏性方法
            将数组中符合条件的元素保存到一个新数组中返回。
                需要一个回调函数做为参数，会为每一个元素去调用回调函数，
                并根据返回值来决定是否将元素添加到新数组,返回值为true则添加到新数组，false则不添加。

            回调函数需要三个参数
                element 数组中的元素
                index   数组中的索引
                array   当前被遍历的数组

        4.map(()=>{})   
            根据当前数组生成新数组
            参数：
                需要一个回调函数做为参数,回调函数的返回值做为新数组的元素。
            回调函数需要三个参数
                element 数组中的元素
                index   数组中的索引
                array   当前被遍历的数组

        5.reduce()
            可以用来将一个数组中所有元素整合为一个值。
            参数：
            需要一个回调函数做为参数,回调函数的返回值做为新数组的元素。
                第一个参数，就是回调函数
                第二个可选参数，就是要整合的起始值

            回调函数需要两个参数
                第一个参数就是前两个数整合之后的值
                第二个参数是要整合的相邻的下一个值
                例如 arr=[0,1,2,3,4]
                
                arr.reduce((a,b)=> a+b)
                第一次调用        a=0,b=1
                第二次调用        a=1,b=2 
                第三次调用        a=3,b=3
                第四次调用        a=6,b=4

            回调函数的返回值    最后的整合值
        */


        let str = 'acefdb'
        let arr = str.split(``)
        let num_arr = [0, 1, 3, 5, 6, 9, 8, 4, 7, 2, 10]

        console.log(`排序前${arr}`)

        // 1.sort()用来对数组进行排序
        arr.sort()   // 默认排序
        num_arr.sort()
        console.log(`排序后${arr}`)
        console.log(`数值排序后${num_arr}`)

        num_arr.sort((a, b) => a - b)    // 升序
        console.log(`使用回调函数做为参数进行数值排序后${num_arr}`)
        num_arr.sort((a, b) => b - a)    // 降序
        console.log(`使用回调函数做为参数进行数值排序后${num_arr}`)

        // 2.forEach(()=>)  用来遍历数组
        arr.forEach((element, index, array) => {

            console.log(index, element)

        })

        //  3.filter(()=>{})    将数组中符合条件的元素保存到一个新数组中返回。
        new_num_arr = num_arr.filter((element) => element % 2 === 0)
        console.log(new_num_arr)

        // 4.map(=>)   根据当前数组生成新数组
        num_arr.map((element) => { return 2 * element })
        console.log(num_arr.map((element) => { return 2 * element }))
        arr.map(element => `<${element}>`)
        console.log(arr.map(element => `<${element}>`))

        // 5.reduce()
        num_arr.reduce((a, b) => a + b)
        console.log(num_arr.reduce((a, b) => a + b))


// 遍历数组
        let arr1=[1,2,3,4,5,6,7,8,9]

       arr1.forEach((i)=>console.log(i))
        arr1.filter((i)=>true)
        arr1.map((i)=>i)
    </script>
</head>

<body>

</body>

</html>